Celestin Apprentice 7/Apprentice-Release7.iso/Environments/Small Eiffel 0.4.8/misc/SmallEiffel.FAQ

Text File | 1997-01-03 | 5KB | 113 lines

Frequently Asked Questions about SmallEiffel :
--------------------------------------------

Q01: Why the name SmallEiffel ?

Q02: What about the version numbering ?

Q03: Is it possible to have the complete Eiffel source of
     SmallEiffel ?

Q04: Is it possible to use SmallEiffel for large/commercial
     applications ?

Q05: Is it possible to do incremental compilation with
     SmallEiffel ?

Q06: Electronic Information available for SmallEiffel.

Q07: What can I do when the compiler (compile_to_c) emits
     a strange Warning like :
     ****** Warning : Call on a Void or a bad target ...
     ... Compiler (SmallEiffel/cc/gcc) may fail because of
     System Validity Problem. Sorry.
     Usually, the C generated code cannot be compiled.

Q08: What about the Guru section ?

Q09: Is it difficult to switch from ISE to SmallEiffel ?

----------------------------------------

A01: It comes from the mixing of the names Smalltalk and Eiffel.
     Our aim is to do an Eiffel environment as easy to use
     as Smalltalk and as safe as Eiffel.

A02: Version numbering uses negative numbers. Usually, the
     greater the number, the more advanced is the version. The
     first distributed version was numbered -0.99
     Version number -0.0 should correspond to the very best
     Eiffel compiler on this planet :-)

A03: No. SmallEiffel distribution already includes a lot of Eiffel
     source files used to write the SmallEiffel compiler itself.
     For example, the class DICTIONARY is the one used by the
     SmallEiffel compiler to store features and all kinds of
     symbolic information. Class FILE_TOOLS, STD_FILE_READ and
     STD_FILE_WRITE are also used by the compiler to read Eiffel
     source code and to write and compare C files. The full C
     source code of the compiler is free. SmallEiffel may one day
     become a commercial product (if someone wants to buy it :-).
     Even if SmallEiffel becomes a commercial product, the C source
     file will remain in public domain and its new owner will have
     to give the C code of further releases.

A04: It is possible to use SmallEiffel for a large application. An
     Eiffel compiler is a really big project and SmallEiffel itself
     is fully written in (Small)Eiffel. SmallEiffel is completely free
     and any private compagny can use SmallEiffel freely, and distribute
     freely the products made with it. They do not have to pay royalties.
     However, SmallEiffel doesn't come with any varranty (please read
     the DISCLAIMER file in the distribution). Nonetheless, if you do
     want a warranty and/or an extended support, you will have to pay
     a reasonable fee (each year) for it. It is also possible to discuss
     specific needs you may have in your business. Please contact
     Dominique COLNET at [e-mail] for more information. [You
     may want to do so too if you want to financially support the
     SmallEiffel team and help them keep up the good work !]."

A05: Before release -0.91 the answer was no. Whith the current
     release, the answer is now YES. Because of the
     SmallEiffel type inference mechanism, SmallEiffel always
     produces all needed C files from scratch. As old C files
     are automatically saved, only modified C files are
     recompiled. See SmallEiffel/man/compile.hlp for details.

A06: The official SmallEiffel page is not yet available. We
     recommend Geoff Eldridge's page for Eiffel information :
     http://www.progsoc.uts.edu.au/~geldridg/
     This very nice page also contains indexed information
     for SmallEiffel :
     ~geldridg/compiler/smalleiffel/index.html

A07: Such a warning gives you an important information about
     the validity of the program you wrote. The problem is
     that you are using a kind of object which can never be
     created in the living code. The living code is the Eiffel
     code you can reach starting from the root procedure of the
     system. In such a case, there is no creation call in the
     living code for the corresponding type. This call is thus
     bound to be a call on a Void target at run time. One
     possible workaround is to add one creation call in the living
     code (the best way to do it is to add a creation call using
     a local variable in the starting procedure).

A08: Some feature section of the SmallEiffel library are labelled
     with :
               feature -- The Guru section :
     If you really need your software to be portable on other Eiffel
     compilers, do not use those features.

A09: If your original ISE software only uses simple types like
     INTEGER, STRING, ARRAY, BOOLEAN, CHARACTER and DOUBLE, it is
     usually very simple. It is a little bit difficult for simple
     input/output (used with predefined `io') because some features
     have different names. If your original software heavily relies
     on the EiffelBase library, it may be very difficult. For
     example, one must keep in mind that SmallEiffel.ARRAY inherit
     SmallEiffel.COLLECTION and that ISE library also have a class
     COLLECTION. By the way, subclasses of ISE.COLLECTION cannot be
     used. The ISE.LINKED_LIST can be used in conjunction with
     SmallEiffel.ARRAY because ISE.LINKED_LIST do not inherit
     ISE.COLLECTION (no clash).